const dataKit = require( "./dataKit")
const dateKit = require( "./dateKit");
const util = require( "./util");
/**
 * 注意：使用await的方法必须加上async，不然会报错！！
 */
module.exports = {
   /**
    * 根据名称获取商户
    * @param {*} userNick 
    */
   async getMerchantByNickname(context,userNick){
      if(!userNick){
         console.info("getMerchantByNickname--->nickname是必须的");
         return null;
      }
      //过滤条件
      const filter = {userNick: userNick};
      let merchant =await dataKit.findOne(context,"merchant",filter);
      return merchant;
   },


   /**
    * 根据openId获取商户
    * @param {*} openId 商户的openid
    */
   async getMerchantByOpenId(context,openId){
      if(!openId){
         console.info("getMerchantByOpenId --> openId是必须的");
         return {code:500,msg:"getMerchantByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId};
      let merchant =await dataKit.findOne(context,"merchant",filter);
      return merchant;
   },


   /**
    * 获取商户的AccessToken
    * @param {*} openId 商户的openid
    */
   async getMerchantAccessToken(context,openId){
      const merchant =await this.getMerchantByOpenId(context,openId);
      return merchant.accessToken;
   },
    /**
    * 根据openId获取商户
    * @param {*} openId 
    */
   async getUserInfoByOpenId(context,openId){
      if(!openId){
         console.info("getUserInfoByOpenId --> openId是必须的");
         return {code: 500, msg: "getUserInfoByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId};
      let userInfo =await dataKit.findOne(context,"user_info",filter);
      return userInfo;
   },

   /**
    * 根据openId获取游戏记录
    * @param {*} openId 
    */
   async getGameRecordByOpenId(context,openId){
      if(!openId){
         console.info("getGameRecordByOpenId --> openId是必须的");
         return {code: 500, msg: "getGameRecordByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId};
      let gameRecord =await dataKit.findOne(context,"game_record",filter);
      return gameRecord;
   },

   /**
    * 根据filter(过滤条件)获取游戏记录
    * @param {*} openId 
    */
   async getGameRecordFilter(context,filter){
      //过滤条件
      let gameRecord =await dataKit.findOne(context,"game_record",filter);
      return gameRecord;
   },

   /**
    * 根据openId获取最新游戏记录
    * @param {*} openId 
    */
   async getNewestGameRecord(context,openId){
      if(!openId){
         console.info("getGameRecordByOpenId --> openId是必须的");
         return {code: 500, msg: "getGameRecordByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId,isSuccess:true};
      let gameRecordList =await dataKit.find(context,"game_record",filter);
      gameRecordList == null ? gameRecordList = [] : gameRecordList;
      return gameRecordList;
   },



   /**
    * 根据openId获取抽奖记录列表
    * @param {*} openId 
    */
   async getPrizeLogList(context,openId){
      if(!openId){
         console.info("getPrizeLogList --> openId是必须的");
         return {code: 500, msg: "getPrizeLogList --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId};
      let prizeLogList =await dataKit.find(context,"prize_log",filter);
      return prizeLogList;
   },

   /**
    * 获取奖品列表
    * @param {*} openId 
    */
   async getPrizeList(context){
      let prizeList =await dataKit.find(context,"prize");
      return prizeList;
   },

   
   /**
    * 根据level获取奖品
    * @param {*} level 
    */
   async getPrizeByLevel(context,level){
     if(!level){
         console.info("getPrizeByLevel --> level是必须的");
         return {code: 500, msg: "getPrizeByLevel --> level是必须的"};
      }
      //过滤条件
      const filter = {level: level};
      let prize =await dataKit.findOne(context,"prize",filter);
      return prize;
   },

   /**
    * 根据openId获取抽奖记录列表
    * @param {*} openId 
    */
   async getPrizeLogList(context,openId){
      if(!openId){
         console.info("getGameRecordByOpenId --> openId是必须的");
         return {code: 500, msg: "getUserInfoByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId: openId};
      let prizeLog =await dataKit.find(context,"prize_log",filter);
      return prizeLog;
   },

   /**
    * 根据openId获取中奖记录列表
    * @param {*} openId 
    */
   async getPrizeLogByopenIdList(context,openId){
      if(!openId){
         console.info("getGameRecordByOpenId --> openId是必须的");
         return {code: 500, msg: "getUserInfoByOpenId --> openId是必须的"};
      }
      //过滤条件
      const filter = {openId:openId,isWinPrize:true};
      //const filter = {openId:openId,isWinPrize:true,type:1};
      let prizeLog =await dataKit.find(context,"prize_log",filter,{sort: {createTime: -1} });
      return prizeLog;
   },

   /**
    * 商品列表
    * @param {*} context 
    * @param {*} openId 商户的openid
    * @param {*} cid 类目id
    */
   async getProductList(context,openId){
      const accessToken =await this.getMerchantAccessToken(context,openId);
      const result = await context.cloud.topApi.invoke({  
        api: 'taobao.items.onsale.get',  
        autoSession: false,
        data:{
           session:accessToken,
           fields:"num_iid,title,cid,price,pic_url",
           page_size:200
        }  
      });
      return result;
   },

    /**
    * 每日打卡
    * @param {} context 
    * @param {*} openId 
    */
    async punchCard(context,openId){
      var currentDate = await dateKit.getCurrentDate();
      var taskRecordList = await dataKit.find(context,"task_record",{openId:openId,createTime:currentDate,type:'sgin'});
      if(taskRecordList.length > 0){
        return {code:500,msg:'用户今天已打卡,不能进行重复打卡'};
      }
      //添加游戏次数
      var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
      await dataKit.update(context, "user_info", {openId:openId},{gameNum:userInfo.gameNum + 1});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userInfo.userNick,//用户淘宝昵称
        type:'sgin',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'每日打卡',	//备注
        participantOpenId:openId,	//参与者openId
        participantUserNick:userInfo.userNick,	//参与者昵称
        participantHeadIcon:userInfo.avatar,	//参与者头像
        createTime:currentDate,	//保存时间
      }
      await dataKit.insertOne(context,'task_record',taskRecord);
      //用户打卡埋点       
      await this.buriedPoint(context,openId,{userNick:userInfo.userNick,type:7,remark:'每日打卡',data:''})
      return {code:200,msg:'用户打卡成功'}
    },

    /**
    * 每日打卡记录
    * @param {} context 
    * @param {*} openId 
    */
    async punchCardRecord(context,openId){
      if(!openId){
        return {code:500,msg:"punchCardRecord --> openId是必须的"}
      }
      var currentDate = await dateKit.getCurrentDate();
      var taskRecord = await dataKit.findOne(context,"task_record",{openId:openId,createTime:currentDate,type:'sgin'});
      taskRecord == null ? taskRecord = {} : taskRecord;
      return {code:200,msg:"查询成功",data:taskRecord};
    },


 
    /**
     * 关注店铺
     * @param {*} context 
     * @param {*} openId 
     */
    async focusShop(context,openId){
      let taskRecordinfo = await dataKit.findOne(context,"task_record",{openId:openId,type:'follow'});
      if(taskRecordinfo != null){
        return {code:500,msg:'用户已关注过该店铺,不允许重复关注'};
      }
      //游戏次数 （+1）
      var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
      await dataKit.update(context, "user_info", {openId:openId},{gameNum:userInfo.gameNum + 1});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userInfo.userNick,//用户淘宝昵称
        type:'follow',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'关注店铺',	//备注
        participantOpenId:'',	//参与者openId
        participantUserNick:'',	//参与者昵称
        participantHeadIcon:'',	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }
      await dataKit.insertOne(context,'task_record',taskRecord);
      //用户关注店铺埋点       
      await this.buriedPoint(context,openId,{userNick:userInfo.userNick,type:5,remark:'关注店铺',data:''})
      return {code:200,msg:'关注店铺成功'};
    },


    /**
     * 关注店铺
     * @param {*} context 
     * @param {*} openId 
     */
    async focusShopRecord(context,openId){
       if(!openId){
        return {code:500,msg:"focusShopRecord --> openId是必须的"}
      }
      var focusShopRecord = await dataKit.findOne(context,"task_record",{openId:openId,type:'follow'});
      focusShopRecord == null ? focusShopRecord = {} : focusShopRecord;
      return {code:200,msg:'查询成功',data:focusShopRecord};
    },

    /**
     * 入会
     * @param {*} context 
     * @param {*} openId 
     */
    async Membership(context,openId){
      let Membership = await dataKit.findOne(context,"task_record",{openId:openId,type:'joinMember'});
      if(Membership != null){
        return {code:500,msg:'用户已入会,不允许重复入会'};
      }
      //游戏次数 （+1）
      var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
      await dataKit.update(context, "user_info", {openId:openId},{gameNum:userInfo.gameNum + 1});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userInfo.userNick,//用户淘宝昵称
        type:'joinMember',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'入会',	//备注
        participantOpenId:'',	//参与者openId
        participantUserNick:'',	//参与者昵称
        participantHeadIcon:'',	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }
      await dataKit.insertOne(context,'task_record',taskRecord);
      //用户入会埋点       
      await this.buriedPoint(context,openId,{userNick:userInfo.userNick,type:3,remark:'入会',data:''})
      return {code:200,msg:'入会成功'};
    },


    /**
     * 入会记录
     * @param {*} context 
     * @param {*} openId 
     */
    async MembershipRecord(context,openId){
       if(!openId){
        return {code:500,msg:"MembershipRecord --> openId是必须的"}
      }
      var MembershipRecord = await dataKit.findOne(context,"task_record",{openId:openId,type:'joinMember'});
      MembershipRecord == null ? MembershipRecord = {} : MembershipRecord;
      return {code:200,msg:'查询成功',data:MembershipRecord};
    },

    /**
     * 分享活动
     * @param {*} context 
     * @param {*} openId 
     */
    async share(context,openId,userNick,participantOpenId){
      if(openId == participantOpenId){
        return {code:500,msg:"不允许自己分享给自己"}
      }
      let share = await dataKit.findOne(context,"task_record",{openId:openId,participantOpenId:participantOpenId,type:'share'});
      if(share != null){
        return {code:500,msg:"不允许重复分享"}
      }
      var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:participantOpenId});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userNick,//用户淘宝昵称
        type:'share',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'分享活动',	//备注
        participantOpenId:participantOpenId,	//参与者openId
        participantUserNick:participantUserInfo.userNick,	//参与者昵称
        participantHeadIcon:participantUserInfo.avatar,	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }
      await dataKit.insertOne(context,'task_record',taskRecord)
      
      let shareList = await dataKit.find(context,"task_record",{participantOpenId:participantOpenId,type:'share'});
      if(shareList.length > 0 && shareList.length % 5 == 0){
        //游戏次数 （+1）
        await dataKit.update(context, "user_info", {openId:participantOpenId},{gameNum:participantUserInfo.gameNum + 1});
      }

      return {code:200,msg:'分享活动成功'};
    },

    /**
     * 分享活动
     * @param {*} context 
     * @param {*} openId 
     */
    // async share(context,openId,userNick,participantOpenId){
    //   var sharesList = await context.cloud.db.collection('task_record').find({openId:openId,type:'share',createTime:dateKit.getTodayCondiction()})
    //   var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:openId});
    //   if(sharesList.length >= 5){
    //     return {code:500,msg:'分享活动已完成'};
    //   }else{
    //     var taskRecord = {
    //       openId:openId,//用户唯一标识
    //       userNick:participantUserInfo.userNick,//用户淘宝昵称
    //       type:'share',	//任务类型：
    //       productId:'',//商品id（浏览商品的时候用到，其他情况为空）
    //       remark:'分享活动',	//备注
    //       participantOpenId:openId,	//参与者openId
    //       participantUserNick:participantUserInfo.userNick,	//参与者昵称
    //       participantHeadIcon:participantUserInfo.avatar,	//参与者头像
    //       createTime:dateKit.getCurrentDateTime(),	//保存时间
    //     }
    //     await dataKit.insertOne(context,'task_record',taskRecord)
    //   }
    //   if(sharesList.length == 4){
    //     //游戏次数 （+1）
    //     await dataKit.update(context, "user_info", {openId:openId},{gameNum:participantUserInfo.gameNum + 1});
    //   }
    //   return {code:200,msg:'分享活动成功'};
    // },

    /**
     * 分享活动明细
     * @param {*} context 
     * @param {*} openId 
     */
    async shareDetail(context,openId){
       if(!openId){
        return {code:500,msg:"shareDetail --> openId是必须的"}
      }
      var shareDetailList = await dataKit.find(context,"task_record",{participantOpenId:openId,type:'share'});
      // var shareDetailList = await context.cloud.db.collection('task_record').find({participantOpenId:openId,type:'share',createTime: dateKit.getTodayCondiction()},{   
      //       sort: {createTime: -1} 
      //   });
      shareDetailList.length == 0 ? shareDetailList = [] : shareDetailList;
      return {code:200,msg:'查询成功',data:shareDetailList};
    },

    /**
     * 邀请好友关注
     * @param {*} context 
     * @param {*} openId 
     */
    async inviteToFollow(context,openId,userNick,participantOpenId){
      if(openId == participantOpenId){
        return {code:500,msg:"不允许自己邀请自己关注"}
      }
      let inviteToFollow = await dataKit.findOne(context,"task_record",{openId:openId,participantOpenId:participantOpenId,type:'inviteToFollow'});
      if(inviteToFollow != null){
        return {code:500,msg:"不允许重复邀请同个好友关注"}
      }
      var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:participantOpenId});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userNick,//用户淘宝昵称
        type:'inviteToFollow',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'邀请好友关注',	//备注
        participantOpenId:participantOpenId,	//参与者openId
        participantUserNick:participantUserInfo.userNick,	//参与者昵称
        participantHeadIcon:participantUserInfo.avatar,	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }

      await dataKit.insertOne(context,'task_record',taskRecord);
      let inviteToFollowList = await dataKit.find(context,"task_record",{participantOpenId:participantOpenId,type:'inviteToFollow'});
      if(inviteToFollowList.length > 0 && inviteToFollowList.length % 3 == 0){
        //游戏次数 （+1）
        await dataKit.update(context, "user_info", {openId:participantOpenId},{gameNum:participantUserInfo.gameNum + 1});
      }
      //用户邀请好友关注埋点       
      await this.buriedPoint(context,openId,{userNick:userNick,type:6,remark:'邀请好友关注',data:''})
      return {code:200,msg:'邀请好友关注成功'};
    },

    // async inviteToFollow(context,openId,userNick,participantOpenId){
    //   var sharesList = await context.cloud.db.collection('task_record').find({openId:openId,type:'inviteToFollow',createTime:dateKit.getTodayCondiction()})
    //   var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:openId});
    //   if(sharesList.length >= 3){
    //     return {code:500,msg:'邀请已完成'};
    //   }else{
    //     var taskRecord = {
    //       openId:openId,//用户唯一标识
    //       userNick:participantUserInfo.userNick,//用户淘宝昵称
    //       type:'inviteToFollow',	//任务类型：
    //       productId:'',//商品id（浏览商品的时候用到，其他情况为空）
    //       remark:'邀请好友关注',	//备注
    //       participantOpenId:openId,	//参与者openId
    //       participantUserNick:participantUserInfo.userNick,	//参与者昵称
    //       participantHeadIcon:participantUserInfo.avatar,	//参与者头像
    //       createTime:dateKit.getCurrentDateTime(),	//保存时间
    //     }
    //     await dataKit.insertOne(context,'task_record',taskRecord)
    //   }
    //   if(sharesList.length == 2){
    //     //游戏次数 （+1）
    //     await dataKit.update(context, "user_info", {openId:openId},{gameNum:participantUserInfo.gameNum + 1});
    //   }
    //   return {code:200,msg:'邀请成功'};
    // },

    /**
     * 邀请好友关注明细
     * @param {*} context 
     * @param {*} openId 
     */
    async inviteToFollowDetail(context,openId){
       if(!openId){
        return {code:500,msg:"inviteToMemberListDetail --> openId是必须的"}
      }
      var inviteToFollowDetailList = await dataKit.find(context,"task_record",{participantOpenId:openId,type:'inviteToFollow'});
      // var inviteToFollowDetailList = await context.cloud.db.collection('task_record').find({participantOpenId:openId,type:'inviteToFollow',createTime: dateKit.getTodayCondiction()},{   
      //       sort: {createTime: -1}  
      //   });
      inviteToFollowDetailList.length == 0 ? inviteToFollowDetailList = [] : inviteToFollowDetailList;
      return {code:200,msg:'查询成功',data:inviteToFollowDetailList};
    },

     /**
     * 邀请好友入会
     * @param {*} context 
     * @param {*} openId 
     */
    async inviteToMember(context,openId,userNick,participantOpenId){
      if(openId == participantOpenId){
        return {code:500,msg:"不允许自己邀请自己入会"}
      }
      let inviteToMember = await dataKit.findOne(context,"task_record",{openId:openId,participantOpenId:participantOpenId,type:'inviteToMember'});
      if(inviteToMember != null){
        return {code:500,msg:"不允许重复邀请同个好友入会"}
      }
      var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:participantOpenId});
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userNick,//用户淘宝昵称
        type:'inviteToMember',	//任务类型：
        productId:'',//商品id（浏览商品的时候用到，其他情况为空）
        remark:'邀请好友入会',	//备注
        participantOpenId:participantOpenId,	//参与者openId
        participantUserNick:participantUserInfo.userNick,	//参与者昵称
        participantHeadIcon:participantUserInfo.avatar,	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }
      await dataKit.insertOne(context,'task_record',taskRecord)
      //游戏次数 （+1）
      await dataKit.update(context, "user_info", {openId:participantOpenId},{gameNum:participantUserInfo.gameNum + 1});
      //用户邀请好友入会埋点       
      await this.buriedPoint(context,openId,{userNick:userNick,type:4,remark:'邀请好友入会',data:''})
      return {code:200,msg:'邀请好友入会成功'};
    },

    // async inviteToMember(context,openId,userNick,participantOpenId){
    //   var sharesList = await context.cloud.db.collection('task_record').find({openId:openId,type:'inviteToMember',createTime:dateKit.getTodayCondiction()})
    //   var participantUserInfo = await dataKit.findOne(context,"user_info",{openId:openId});
    //   if(sharesList.length >= 1){
    //     return {code:500,msg:'邀请好友入会已完成'};
    //   }else{
    //     var taskRecord = {
    //       openId:openId,//用户唯一标识
    //       userNick:participantUserInfo.userNick,//用户淘宝昵称
    //       type:'inviteToMember',	//任务类型：
    //       productId:'',//商品id（浏览商品的时候用到，其他情况为空）
    //       remark:'邀请好友入会',	//备注
    //       participantOpenId:openId,	//参与者openId
    //       participantUserNick:participantUserInfo.userNick,	//参与者昵称
    //       participantHeadIcon:participantUserInfo.avatar,	//参与者头像
    //       createTime:dateKit.getCurrentDateTime(),	//保存时间
    //     }
    //     await dataKit.insertOne(context,'task_record',taskRecord)
    //   }
    //   //游戏次数 （+1）
    //   await dataKit.update(context, "user_info", {openId:openId},{gameNum:participantUserInfo.gameNum + 1});
    //   //用户邀请好友入会埋点       
    //   await this.buriedPoint(context,openId,{userNick:userNick,type:4,remark:'邀请好友入会',data:''})
    //   return {code:200,msg:'邀请好友入会成功'};
    // },

    /**
     * 每日邀请好友入会明细
     * @param {*} context 
     * @param {*} openId 
     */
    async inviteToMemberDetail(context,openId){
       if(!openId){
        return {code:500,msg:"inviteToMemberListDetail --> openId是必须的"}
      }
      var inviteToMemberDetailList = await dataKit.find(context,"task_record",{participantOpenId:openId,type:'inviteToMember'});
      inviteToMemberDetailList.length == 0 ? inviteToMemberDetailList = [] : inviteToMemberDetailList;
      return {code:200,msg:'查询成功',data:inviteToMemberDetailList};
    },

    /**
     * 加购宝贝
     */
    async purchaseBaby(context,openId,userNick,productId){
      let flg = false;
      var record = await dataKit.findOne(context,"task_record",{openId:openId,productId:productId,type:'browseProduct'});
      if(record != null){
        return {code:500,msg:'宝贝已收藏',data:flg}
      }
      var taskRecord = {
        openId:openId,//用户唯一标识
        userNick:userNick,//用户淘宝昵称
        type:'browseProduct',	//任务类型：
        productId:productId,//商品id（浏览商品的时候用到，其他情况为空）
        remark:'加购宝贝',	//备注
        participantOpenId:'',	//参与者openId
        participantUserNick:'',	//参与者昵称
        participantHeadIcon:'',	//参与者头像
        createTime:dateKit.getCurrentDateTime(),	//保存时间
      }

      await dataKit.insertOne(context,'task_record',taskRecord);
      let purchaseBabyList = await dataKit.find(context,"task_record",{openId:openId,type:'browseProduct'});
      if(purchaseBabyList.length > 0 && purchaseBabyList.length % 2 == 0){
        //游戏次数 （+1）
        flg = true;
        var uerInfo = await dataKit.findOne(context,"user_info",{openId:openId});
        await dataKit.update(context, "user_info", {openId:openId},{gameNum:uerInfo.gameNum + 1});
      }
      return {code:200,msg:'加购宝贝成功',data:flg};
    },

    // /**
    // * 每日观看直播
    // * @param {} context 
    // * @param {*} openId
    // * @param {*} sign
    // */
    // async live(context,openId,sign){
    //   var currentDate = await dateKit.getCurrentDate();
    //   var taskRecordList = await dataKit.find(context,"task_record",{openId:openId,createTime:currentDate,type:'live'});
    //   if(taskRecordList.length > 0){
    //     return {code:500,msg:'用户已观看直播,不能进行重复观看'};
    //   }
    //   var startLive = await await dataKit.findOne(context,"task_record",{openId:openId,type:'startlive'});
    //   if(sign == 0){
    //     if(startLive == null){
    //       var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
    //       var taskRecord = {
    //         openId:openId,//用户唯一标识
    //         userNick:userInfo.userNick,//用户淘宝昵称
    //         type:'startlive',	//任务类型：
    //         productId:'',//商品id（浏览商品的时候用到，其他情况为空）
    //         remark:'开始观看直播',	//备注
    //         participantOpenId:'',	//参与者openId
    //         participantUserNick:'',	//参与者昵称
    //         participantHeadIcon:'',	//参与者头像
    //         createTime:dateKit.getCurrentDateTime(),	//保存时间
    //       }
    //       await dataKit.insertOne(context,'task_record',taskRecord);
    //     }
    //     return {code:200,msg:'用户开始观看直播成功'};
    //   }else if(sign == 1){
    //     if(startLive != null){
    //       //删除开始观看直播数据
    //       await dataKit.deleteMany(context,"task_record",{openId:openId,type:'startlive'});
    //       //观看直播15秒
    //       if(Math.abs(new Date(dateKit.getCurrentDateTime()) - new Date(startLive.createTime))/1000 >= 15){
    //         //添加游戏次数
    //         var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
    //         await dataKit.update(context, "user_info", {openId:openId},{gameNum:userInfo.gameNum + 1});
    //         var taskRecord = {
    //           openId:openId,//用户唯一标识
    //           userNick:userInfo.userNick,//用户淘宝昵称
    //           type:'live',	//任务类型：
    //           productId:'',//商品id（浏览商品的时候用到，其他情况为空）
    //           remark:'观看直播',	//备注
    //           participantOpenId:'',	//参与者openId
    //           participantUserNick:'',	//参与者昵称
    //           participantHeadIcon:'',	//参与者头像
    //           createTime:currentDate,	//保存时间
    //         }
    //         await dataKit.insertOne(context,'task_record',taskRecord);
    //         return {code:200,msg:'用户观看15s直播成功'};
    //       }
    //     }
    //   }
    //   return {code:500,msg:'用户观看15s直播失败'};
    // },


    /**
    * 每日观看直播(真果粒项目前端能判断15s)
    * @param {} context 
    * @param {*} openId
    * @param {*} sign
    */
    async live(context,openId,sign){
      var currentDate = await dateKit.getCurrentDate();
      var taskRecordList = await dataKit.find(context,"task_record",{openId:openId,createTime:currentDate,type:'live'});
      if(taskRecordList.length > 0){
        return {code:500,msg:'用户已观看直播,不能进行重复观看'};
      }
      if(sign == 1){
        //添加游戏次数
        var userInfo = await dataKit.findOne(context,"user_info",{openId:openId});
        await dataKit.update(context, "user_info", {openId:openId},{gameNum:userInfo.gameNum + 1});
        var taskRecord = {
          openId:openId,//用户唯一标识
          userNick:userInfo.userNick,//用户淘宝昵称
          type:'live',	//任务类型：
          productId:'',//商品id（浏览商品的时候用到，其他情况为空）
          remark:'观看直播',	//备注
          participantOpenId:'',	//参与者openId
          participantUserNick:'',	//参与者昵称
          participantHeadIcon:'',	//参与者头像
          createTime:currentDate,	//保存时间
        }
        await dataKit.insertOne(context,'task_record',taskRecord);
        return {code:200,msg:'用户观看15s直播成功'};
      }   
      return {code:500,msg:'用户观看15s直播失败'};
    },



    /**
    * 每日观看直播记录
    * @param {} context 
    * @param {*} openId 
    */
    async liveRecord(context,openId){
      if(!openId){
        return {code:500,msg:"liveRecord --> openId是必须的"}
      }
      var currentDate = await dateKit.getCurrentDate();
      var taskRecord = await dataKit.findOne(context,"task_record",{openId:openId,createTime:currentDate,type:'live'});
      taskRecord == null ? taskRecord = {} : taskRecord;
      return {code:200,msg:"查询成功",data:taskRecord};
    },

    /**
     * 埋点
     * @param {埋点} context 
     */
    async buriedPoint(context,openId,userData){
      var buriedPoint = {
                openId:openId,
                userNick:userData.userNick,
                type:userData.type,
                remark:userData.remark,
                data:userData.data,
                createTime:dateKit.getCurrentDateTime()
              };
      await dataKit.insertOne(context,"user_data",buriedPoint);
    },


    /**
     * CRM会员积分变更接口
     * @param {*} context 
     * @param {*} open_id 
     * @param {String} opt_type 操作类型，0：增加，1：扣减 （注意需要传字符串！！）
     * @param {*} quantity  积分数量
     */
    async changePoint(context,open_id,opt_type,quantity) {
       let access_token = await this.getDefaultMerchantAccessToken(context);
        //变更类型：0交易，1：互动活动，2：权益兑换，3：手工调整
        try {
          const change_type = 1;
          const trades = await context.cloud.topApi.invoke({
            api:'taobao.crm.point.change',
            autoSession: false,
            data: {
                session: access_token,
                change_type,
                open_id,
                opt_type,
                quantity
            }
          });
          //return trades;
          return {success:200,msg:trades.request_id}
        } catch (e) {
          return {success:500,msg:e.sub_msg}
        }
    },

     /**
    * 发奖接口 
    * @param {*} context 
    * @param {*} receiver_id  接收奖品的用户openId
    * @param {*} right_ename 发放的权益(奖品)唯一标识
    * @param {*} unique_id 幂等校验id，业务重试需要，自定义唯一字段即可
    *  * 返回：
        result_msg	String	发放成功	接口返回消息
        result_code	String	SEND_SUCCESS	接口返回代码
        result_success	Boolean	true	是否处理成功
        right_id	Number	891033	权益id
        prize_name	String	广陌测试虚拟奖品	奖品名称
    */
   async sendBenefit(context,receiver_id,right_ename,unique_id){
     const accessToken =await this.getDefaultMerchantAccessToken(context);
      var uuid = util.uuid();
      try {
        const result = await context.cloud.topApi.invoke({  
            api: 'alibaba.benefit.send',  
            autoSession: false,
            data:{
              session:accessToken,
              right_ename:right_ename,
              receiver_id:receiver_id,
              unique_id:uuid,
              user_type:"taobao",
              app_name:"mtop",
            }  
          });
          if(result.result_code == "SUCCESS"){
            return {success:200,msg:result.result_msg}
          }else{
            return {success:500,msg:result.result_msg}
          }
      } catch (e) {
        return {success:500,msg:e} 
      } 
   },

    /**
     *  CRM会员积分查询开放接口
     * @param {*} context 上下文
     * @param {*} mix_nick 用户 mix_nick
     */
    async getAvailablePoint(context,mix_nick) {
        const accessToken =await this.getDefaultMerchantAccessToken(context);
        try {
           const result = await context.cloud.topApi.invoke({
            api:'taobao.crm.point.available.get',
            autoSession: false,
            data:{
                session: accessToken,
                mix_nick:mix_nick
            }
        });
         return result;
        } catch (e) {
          return {errr:e}
        }
    },

    /**
     * 获取商家唯一标识
     * @param {} context 
     */
    async getDefaultMerchantAccessToken(context){
      //过滤条件
      const filter = {};
      let merchant =await dataKit.findOne(context,"merchant",filter);
      return merchant.accessToken;
   },

   /**
     * 判断用户是否是会员
     * @param {*} context 上下文
     * @param {*} mix_nick 用户 mix_nick
     */
    async isTaobaoMember(context,mix_nick) {
        const accessToken = await this.getDefaultMerchantAccessToken(context);
        const identity = await context.cloud.topApi.invoke({
            api:'taobao.crm.member.identity.get',
            autoSession: false,
            data:{
                session: accessToken,
                mix_nick: mix_nick
            }
        });
        if (identity.result.member_info) {// 是会员
            return true;
        }else {
            return false;
        }
    },

    async  getCoupons(context,openId,uuid,accessToken) {
      //const accessToken = await this.getDefaultMerchantAccessToken(context);
      try {
        const result = await context.cloud.topApi.invoke({
          api: 'alibaba.shop.coupon.apply',
          data: {
            'open_id' : openId,
            'uuid' : uuid,
            'session': accessToken
          }
        });
        return { success: true, data: result ,aa: uuid,bb: openId,cc: accessToken};
      } catch (e) {
        return {success: false, data: e,aa: uuid,bb: openId,cc: accessToken}
      }
    }

   


}
